import axios, { AxiosRequestConfig, AxiosResponse } from 'axios';
import { ElMessage } from 'element-plus';
import { useUserStore } from '@/store/modules/user';

/**
 * RuoYi项目专用的request函数
 * 统一处理错误、数据格式、token等
 */

// 创建专用的axios实例
const ruoyiAxios = axios.create({
  timeout: 60000,
  baseURL: import.meta.env.VITE_API_URL,
  withCredentials: false,
});

// 请求拦截器
ruoyiAxios.interceptors.request.use(
  (config) => {
    console.log(`[Request] 🚀 发送请求:`, {
      url: config.url,
      method: config.method,
      params: config.params,
      data: config.data
    });

    // 添加token
    const userStore = useUserStore();
    const token = userStore.accessToken;
    
    if (token && config.headers?.isToken !== false) {
      config.headers.Authorization = `Bearer ${token}`;
    }
    
    // 移除自定义isToken字段
    if (config.headers?.isToken !== undefined) {
      delete config.headers.isToken;
    }
    
    return config;
  },
  (error) => Promise.reject(error)
);

// 响应拦截器 - 统一处理RuoYi响应格式
ruoyiAxios.interceptors.response.use(
  (response: AxiosResponse) => {
    const { data } = response;
    
    console.log(`[Request] 📥 接收响应:`, {
      url: response.config.url,
      status: response.status,
      data: data,
      hasRows: !!(data && data.rows),
      hasData: !!(data && data.data),
      hasTotal: !!(data && data.total)
    });
    
    // 🛡️ RuoYi响应格式安全处理
    if (!data) {
      console.warn('[Request] ⚠️ 响应数据为空，返回默认结构');
      return { rows: [], total: 0, code: 200, msg: '无数据' };
    }

    if (typeof data !== 'object') {
      console.warn('[Request] ⚠️ 响应数据不是对象，返回默认结构');
      return { rows: [], total: 0, code: 200, msg: '数据格式异常' };
    }

    // 检查是否是错误响应
    if (data.code && data.code !== 200) {
      ElMessage.error(data.msg || '请求失败');
      return Promise.reject(new Error(data.msg || '请求失败'));
    }

    // 🔧 智能响应处理：根据数据特征返回不同格式
    const safeResponse = {
      ...data,
      rows: data.rows || data.data || [],
      total: data.total || data.count || 0,
      code: data.code || 200,
      msg: data.msg || '成功'
    };

    console.log('[Request] 🔧 智能响应处理分析:', {
      originalHasRows: !!data.rows,
      originalHasData: !!data.data,
      responseType: data.rows !== undefined ? 'LIST' : (data.data !== undefined ? 'OBJECT' : 'OTHER'),
      finalRows: safeResponse.rows?.length || 0,
      finalTotal: safeResponse.total
    });

    // 🧠 智能返回策略
    if (data.rows !== undefined) {
      // 列表接口：返回完整包装对象供useTable使用
      console.log('[Request] 📊 列表接口 → 返回包装对象 {rows, total, ...}');
      return safeResponse;
    } else if (data.data !== undefined) {
      // 对象接口：直接返回data内容供业务逻辑使用
      console.log('[Request] 🎯 对象接口 → 直接返回业务数据', data.data);
      return data.data;
    } else {
      // 其他情况：返回原始响应
      console.log('[Request] 🔄 其他情况 → 返回原始响应');
      return data;
    }
  },
  (error) => {
    console.error('[Request Error]:', error);
    
    if (error.response) {
      const { status, data } = error.response;
      const message = data?.msg || `请求失败 (${status})`;
      ElMessage.error(message);
    } else if (error.request) {
      ElMessage.error('网络连接失败，请检查网络');
    } else {
      ElMessage.error('请求配置错误');
    }
    
    return Promise.reject(error);
  }
);

interface RequestConfig {
  url: string;
  method?: 'get' | 'post' | 'put' | 'delete';
  params?: Record<string, any>;
  data?: any;
  headers?: Record<string, any>;
  timeout?: number;
  responseType?: 'json' | 'blob' | 'text' | 'arraybuffer';
}

/**
 * 统一的request函数 - 返回RuoYi标准格式
 */
function request(config: RequestConfig): Promise<any> {
  const axiosConfig: AxiosRequestConfig = {
    ...config,
    method: config.method || 'get',
  };

  return ruoyiAxios.request(axiosConfig);
}

export default request;
